﻿///*
// * TiffFrame
// * 
// * initial implementation : 20.9.2008
// *
// * Copyright (c) Adam Sida, asida@centrum.cz.
// * All rights reserved.
// * 
// * for license see Petra.Gis.License.txt
// */
//using System;
//using System.Windows;
//using System.Collections.Generic;
//using Petra.Gis.Geometry.Support;
//using Petra.Gis.Geometry.GridSupport;
//using Petra.Gis.Imaging.Tiff;


//namespace Petra.Gis.DataServices
//{
//  /// <summary>
//  /// represents file based image frame/page from tiff image
//  /// </summary>
//  public class TiffFrame : GridFrame
//  {

//    private BlockBitmapSource _frame;
//    //private List<TiffImageBlock> _gridBlocks = new List<TiffImageBlock>();
//    //private List<GridBlock> _gridBlocks; // = new List<GridBlock>();
//    //private bool _isCreatedFromSelection = false;
//    //private Int32Rect _pixelSize;
//    //private int _pixelWidth;
//    //private int _pixelHeight;
//    //private int _numBlocksHorizontal;
//    //private int _numBlocksVertical;



//    ///// <summary>
//    ///// returns new Frame created/selected from this instance
//    ///// as subselect of rectaglular area of blocks eg.
//    ///// original frame has 300 x 300 blocks
//    ///// subselection has 20 x 20 blocks
//    ///// 1 block is 128 x 128 cells, typically
//    ///// </summary>
//    ///// <param name="frame">caller instance</param>
//    ///// <param name="blocks"> list of blocks subselected from caller instance</param>
//    ///// <param name="bounds">new bounds of subselected blocks area</param>
//    ///// <param name="numBlocksHorizontal">num of blocks in horizontal direction</param>
//    ///// <param name="numBlocksVertical">num of blocks in vertical direction</param>
//    ///// <param name="pixelWidth">subselected frame width</param>
//    ///// <param name="pixelHeight">subselected frame height</param>
//    //private TiffFrame(TiffBitmapPage frame, List<GridBlock> blocks, BoundingBox bounds, int numBlocksHorizontal, int numBlocksVertical, int pixelWidth, int pixelHeight)
//    //{
//    //  _isCreatedFromSelection = true;
//    //  _gridBlocks = blocks;
//    //  _bounds = bounds;
//    //  _pixelWidth = pixelWidth;
//    //  _pixelHeight = pixelHeight;

//    //  _numBlocksHorizontal = numBlocksHorizontal;
//    //  _numBlocksVertical = numBlocksVertical;
//    //  _frame = frame;
//    //}





//    public TiffFrame(BlockBitmapSource frame, BoundingBox bounds)
//    {
//      _frame = frame;
//      _bounds = bounds;

      
//    }




//    public override int Height
//    {
//      get
//      {
//        return _frame.PixelHeight; 
//      }
//    }




//    public override int Width
//    {
//      get
//      {
//        return _frame.PixelWidth;
//      }
//    }





//    public override System.Windows.Media.PixelFormat PixelFormat
//    {
//      get { return _frame.TiffMetadata.MapPixelFormat(); }
//    }



//    //System.Windows.Media.Imaging.BitmapPalette
//    public override object Palette
//    {
//      get { return _frame.Palette; }
//    }





//    public override object Data
//    {
//      get { return _frame; }
//    }




//    //public override int BlockHeight
//    //{
//    //  get { return _frame.TiffMetadata.BlockHeight; }
//    //}




//    //public override int BlockWidth
//    //{
//    //  get { return _frame.TiffMetadata.BlockWidth; }
//    //}





//    //public override GridBlock[] Blocks
//    //{
//    //  get 
//    //  {
//    //    if (_gridBlocks == null)
//    //      buildBlocks();

//    //    return _gridBlocks.ToArray(); 
//    //  }
//    //}





//    //public override GridCells SelectCellsByRange(BoundingBox range)
//    //{
//    //  throw new NotImplementedException();
//    //}






//    //public override GridFrame SelectBlocksByRange(BoundingBox range)
//    //{
//    //  List<GridBlock> result = new List<GridBlock>();

//    //  bool firstLine = true;
//    //  bool rowDone = false;

//    //  int numBlocksHorizontal = 0, numBlocksVertical = 0;

//    //  int pixelWidth = 0;
//    //  int pixelHeight = 0;

//    //  GridBlock tmpBl = null;
//    //  double xlo, ylo, xhi, yhi;
//    //  BoundingBox bb = null;

//    //  // prepare bounds, 
//    //  // flip min&max for compare first
//    //  ylo = _bounds.Top;
//    //  yhi = _bounds.Bottom;
//    //  xlo = _bounds.Right;
//    //  xhi = _bounds.Left;

//    //  for (int y = 0; y < _numBlocksVertical; y++)
//    //  {
//    //    for (int x = 0; x < _numBlocksHorizontal; x++)
//    //    {
//    //      tmpBl = _gridBlocks[(y * _numBlocksHorizontal) + x];
//    //      if (tmpBl.Bounds.Intersects(range))
//    //      {
//    //        result.Add(tmpBl);
//    //        if (xlo > tmpBl.Bounds.Left)
//    //          xlo = tmpBl.Bounds.Left;

//    //        if (ylo > tmpBl.Bounds.Bottom)
//    //          ylo = tmpBl.Bounds.Bottom;

//    //        if (xhi < tmpBl.Bounds.Right)
//    //          xhi = tmpBl.Bounds.Right;

//    //        if (yhi < tmpBl.Bounds.Top)
//    //          yhi = tmpBl.Bounds.Top;

//    //        if (firstLine)
//    //        {
//    //          pixelWidth += tmpBl.PixelWidth;
//    //          numBlocksHorizontal++;
//    //        }
//    //        if (!rowDone)
//    //        {
//    //          pixelHeight += tmpBl.PixelHeight;
//    //          rowDone = true;
//    //          numBlocksVertical++;
//    //        }

//    //      }          
//    //    }
//    //    if (rowDone)
//    //      firstLine = false;

//    //    rowDone = false;
//    //  }

//    //  bb = new BoundingBox(xlo, ylo, xhi, yhi);

//    //  if (result.Count != 0)
//    //  {
//    //    return new TiffFrame(_frame, result, bb, numBlocksHorizontal, numBlocksVertical, pixelWidth, pixelHeight);
//    //  }
//    //  else
//    //    return null;

//    //}





//    public override BoundingBox Bounds
//    {
//      get { return _bounds; }
//      set { _bounds  = value; }
//    }





//    //public override int NumBlocksHorizontal
//    //{
//    //  get { return _numBlocksHorizontal; }
//    //}





//    //public override int NumBlocksVertical
//    //{
//    //  get { return _numBlocksVertical; }
//    //}




//    //protected void buildBlocks()
//    //{

//    //  _gridBlocks = new List<GridBlock>(_numBlocksHorizontal * _numBlocksVertical);

//    //  Int32Rect blockSize;

//    //  // process page blocks
//    //  // setup blocks dimensions and positions
//    //  // get pixel size
//    //  double pixelWidth = _bounds.Width / _frame.PixelWidth;
//    //  double pixelHeight = _bounds.Height / _frame.PixelHeight;

//    //  double lastPosX, lastPosY;
//    //  double blockWrldHeight = 0, blockWrldWidth = 0;
//    //  //BitmapBlock tmpBl;

//    //  int blockId;
//    //  int BlWidth = _frame.TiffMetadata.BlockWidth;
//    //  int BlHeight = _frame.TiffMetadata.BlockHeight;
//    //  int ImgWidth = _frame.TiffMetadata.Width;
//    //  int ImgHeight = _frame.TiffMetadata.Height;

//    //  // build blocks...
//    //  lastPosY = _bounds.Top;
//    //  for (int y = 0; y < _numBlocksVertical; y++)
//    //  {
//    //    lastPosX = _bounds.Left;
//    //    for (int x = 0; x < _numBlocksHorizontal; x++)
//    //    {
//    //      blockId = (y * _numBlocksHorizontal) + x;
//    //      //tmpBl = _frame.Blocks[blockId];
//    //      //blockWrldWidth = (tmpBl.Bounds.Width * 1.0) * pixelWidth;
//    //      //blockWrldHeight = (tmpBl.Bounds.Height * 1.0) * pixelHeight;

//    //      blockSize = new Int32Rect();
//    //      blockSize.X = x * BlWidth;
//    //      blockSize.Y = y * BlHeight;
//    //      blockSize.Width = ((blockSize.X + BlWidth) > ImgWidth) ? (ImgWidth - blockSize.X) : BlWidth;
//    //      blockSize.Height = ((blockSize.Y + BlHeight) > ImgHeight) ? (ImgHeight - blockSize.Y) : BlHeight;

//    //      blockWrldWidth = (blockSize.Width * 1.0) * pixelWidth;
//    //      blockWrldHeight = (blockSize.Height * 1.0) * pixelHeight;
//    //      BoundingBox bb = new BoundingBox(lastPosX, lastPosY - blockWrldHeight, lastPosX + blockWrldWidth, lastPosY);
//    //      _gridBlocks.Add(new TiffImageBlock(_frame.Blocks, blockId, bb));
//    //      lastPosX += blockWrldWidth;
//    //    }
//    //    lastPosY -= blockWrldHeight;
//    //  }
//    //}

//  }
//}
